home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / lang / SecurityManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  7.6 KB  |  426 lines
  1. package java.lang;
  2.  
  3. import java.io.File;
  4. import java.io.FileDescriptor;
  5. import java.io.FilePermission;
  6. import java.net.InetAddress;
  7. import java.net.SocketPermission;
  8. import java.security.AccessControlContext;
  9. import java.security.AccessController;
  10. import java.security.Permission;
  11. import java.security.SecurityPermission;
  12. import java.util.PropertyPermission;
  13. import java.util.StringTokenizer;
  14. import sun.security.util.SecurityConstants;
  15.  
  16. public class SecurityManager {
  17.    /** @deprecated */
  18.    @Deprecated
  19.    protected boolean inCheck;
  20.    private boolean initialized = false;
  21.    private static ThreadGroup rootGroup = getRootGroup();
  22.    private static boolean packageAccessValid = false;
  23.    private static String[] packageAccess;
  24.    private static final Object packageAccessLock = new Object();
  25.    private static boolean packageDefinitionValid = false;
  26.    private static String[] packageDefinition;
  27.    private static final Object packageDefinitionLock = new Object();
  28.  
  29.    private boolean hasAllPermission() {
  30.       try {
  31.          this.checkPermission(SecurityConstants.ALL_PERMISSION);
  32.          return true;
  33.       } catch (SecurityException var2) {
  34.          return false;
  35.       }
  36.    }
  37.  
  38.    /** @deprecated */
  39.    @Deprecated
  40.    public boolean getInCheck() {
  41.       return this.inCheck;
  42.    }
  43.  
  44.    public SecurityManager() {
  45.       synchronized(SecurityManager.class) {
  46.          SecurityManager var2 = System.getSecurityManager();
  47.          if (var2 != null) {
  48.             var2.checkPermission(new RuntimePermission("createSecurityManager"));
  49.          }
  50.  
  51.          this.initialized = true;
  52.       }
  53.    }
  54.  
  55.    protected native Class[] getClassContext();
  56.  
  57.    /** @deprecated */
  58.    @Deprecated
  59.    protected ClassLoader currentClassLoader() {
  60.       ClassLoader var1 = this.currentClassLoader0();
  61.       if (var1 != null && this.hasAllPermission()) {
  62.          var1 = null;
  63.       }
  64.  
  65.       return var1;
  66.    }
  67.  
  68.    private native ClassLoader currentClassLoader0();
  69.  
  70.    /** @deprecated */
  71.    @Deprecated
  72.    protected Class<?> currentLoadedClass() {
  73.       Class var1 = this.currentLoadedClass0();
  74.       if (var1 != null && this.hasAllPermission()) {
  75.          var1 = null;
  76.       }
  77.  
  78.       return var1;
  79.    }
  80.  
  81.    /** @deprecated */
  82.    @Deprecated
  83.    protected native int classDepth(String var1);
  84.  
  85.    /** @deprecated */
  86.    @Deprecated
  87.    protected int classLoaderDepth() {
  88.       int var1 = this.classLoaderDepth0();
  89.       if (var1 != -1) {
  90.          if (this.hasAllPermission()) {
  91.             var1 = -1;
  92.          } else {
  93.             --var1;
  94.          }
  95.       }
  96.  
  97.       return var1;
  98.    }
  99.  
  100.    private native int classLoaderDepth0();
  101.  
  102.    /** @deprecated */
  103.    @Deprecated
  104.    protected boolean inClass(String var1) {
  105.       return this.classDepth(var1) >= 0;
  106.    }
  107.  
  108.    /** @deprecated */
  109.    @Deprecated
  110.    protected boolean inClassLoader() {
  111.       return this.currentClassLoader() != null;
  112.    }
  113.  
  114.    public Object getSecurityContext() {
  115.       return AccessController.getContext();
  116.    }
  117.  
  118.    public void checkPermission(Permission var1) {
  119.       AccessController.checkPermission(var1);
  120.    }
  121.  
  122.    public void checkPermission(Permission var1, Object var2) {
  123.       if (var2 instanceof AccessControlContext) {
  124.          ((AccessControlContext)var2).checkPermission(var1);
  125.       } else {
  126.          throw new SecurityException();
  127.       }
  128.    }
  129.  
  130.    public void checkCreateClassLoader() {
  131.       this.checkPermission(SecurityConstants.CREATE_CLASSLOADER_PERMISSION);
  132.    }
  133.  
  134.    private static ThreadGroup getRootGroup() {
  135.       ThreadGroup var0;
  136.       for(var0 = Thread.currentThread().getThreadGroup(); var0.getParent() != null; var0 = var0.getParent()) {
  137.       }
  138.  
  139.       return var0;
  140.    }
  141.  
  142.    public void checkAccess(Thread var1) {
  143.       if (var1 == null) {
  144.          throw new NullPointerException("thread can't be null");
  145.       } else {
  146.          if (var1.getThreadGroup() == rootGroup) {
  147.             this.checkPermission(SecurityConstants.MODIFY_THREAD_PERMISSION);
  148.          }
  149.  
  150.       }
  151.    }
  152.  
  153.    public void checkAccess(ThreadGroup var1) {
  154.       if (var1 == null) {
  155.          throw new NullPointerException("thread group can't be null");
  156.       } else {
  157.          if (var1 == rootGroup) {
  158.             this.checkPermission(SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
  159.          }
  160.  
  161.       }
  162.    }
  163.  
  164.    public void checkExit(int var1) {
  165.       this.checkPermission(new RuntimePermission("exitVM." + var1));
  166.    }
  167.  
  168.    public void checkExec(String var1) {
  169.       File var2 = new File(var1);
  170.       if (var2.isAbsolute()) {
  171.          this.checkPermission(new FilePermission(var1, "execute"));
  172.       } else {
  173.          this.checkPermission(new FilePermission("<<ALL FILES>>", "execute"));
  174.       }
  175.  
  176.    }
  177.  
  178.    public void checkLink(String var1) {
  179.       if (var1 == null) {
  180.          throw new NullPointerException("library can't be null");
  181.       } else {
  182.          this.checkPermission(new RuntimePermission("loadLibrary." + var1));
  183.       }
  184.    }
  185.  
  186.    public void checkRead(FileDescriptor var1) {
  187.       if (var1 == null) {
  188.          throw new NullPointerException("file descriptor can't be null");
  189.       } else {
  190.          this.checkPermission(new RuntimePermission("readFileDescriptor"));
  191.       }
  192.    }
  193.  
  194.    public void checkRead(String var1) {
  195.       this.checkPermission(new FilePermission(var1, "read"));
  196.    }
  197.  
  198.    public void checkRead(String var1, Object var2) {
  199.       this.checkPermission(new FilePermission(var1, "read"), var2);
  200.    }
  201.  
  202.    public void checkWrite(FileDescriptor var1) {
  203.       if (var1 == null) {
  204.          throw new NullPointerException("file descriptor can't be null");
  205.       } else {
  206.          this.checkPermission(new RuntimePermission("writeFileDescriptor"));
  207.       }
  208.    }
  209.  
  210.    public void checkWrite(String var1) {
  211.       this.checkPermission(new FilePermission(var1, "write"));
  212.    }
  213.  
  214.    public void checkDelete(String var1) {
  215.       this.checkPermission(new FilePermission(var1, "delete"));
  216.    }
  217.  
  218.    public void checkConnect(String var1, int var2) {
  219.       if (var1 == null) {
  220.          throw new NullPointerException("host can't be null");
  221.       } else {
  222.          if (!var1.startsWith("[") && var1.indexOf(58) != -1) {
  223.             var1 = "[" + var1 + "]";
  224.          }
  225.  
  226.          if (var2 == -1) {
  227.             this.checkPermission(new SocketPermission(var1, "resolve"));
  228.          } else {
  229.             this.checkPermission(new SocketPermission(var1 + ":" + var2, "connect"));
  230.          }
  231.  
  232.       }
  233.    }
  234.  
  235.    public void checkConnect(String var1, int var2, Object var3) {
  236.       if (var1 == null) {
  237.          throw new NullPointerException("host can't be null");
  238.       } else {
  239.          if (!var1.startsWith("[") && var1.indexOf(58) != -1) {
  240.             var1 = "[" + var1 + "]";
  241.          }
  242.  
  243.          if (var2 == -1) {
  244.             this.checkPermission(new SocketPermission(var1, "resolve"), var3);
  245.          } else {
  246.             this.checkPermission(new SocketPermission(var1 + ":" + var2, "connect"), var3);
  247.          }
  248.  
  249.       }
  250.    }
  251.  
  252.    public void checkListen(int var1) {
  253.       if (var1 == 0) {
  254.          this.checkPermission(SecurityConstants.LOCAL_LISTEN_PERMISSION);
  255.       } else {
  256.          this.checkPermission(new SocketPermission("localhost:" + var1, "listen"));
  257.       }
  258.  
  259.    }
  260.  
  261.    public void checkAccept(String var1, int var2) {
  262.       if (var1 == null) {
  263.          throw new NullPointerException("host can't be null");
  264.       } else {
  265.          if (!var1.startsWith("[") && var1.indexOf(58) != -1) {
  266.             var1 = "[" + var1 + "]";
  267.          }
  268.  
  269.          this.checkPermission(new SocketPermission(var1 + ":" + var2, "accept"));
  270.       }
  271.    }
  272.  
  273.    public void checkMulticast(InetAddress var1) {
  274.       String var2 = var1.getHostAddress();
  275.       if (!var2.startsWith("[") && var2.indexOf(58) != -1) {
  276.          var2 = "[" + var2 + "]";
  277.       }
  278.  
  279.       this.checkPermission(new SocketPermission(var2, "connect,accept"));
  280.    }
  281.  
  282.    /** @deprecated */
  283.    @Deprecated
  284.    public void checkMulticast(InetAddress var1, byte var2) {
  285.       String var3 = var1.getHostAddress();
  286.       if (!var3.startsWith("[") && var3.indexOf(58) != -1) {
  287.          var3 = "[" + var3 + "]";
  288.       }
  289.  
  290.       this.checkPermission(new SocketPermission(var3, "connect,accept"));
  291.    }
  292.  
  293.    public void checkPropertiesAccess() {
  294.       this.checkPermission(new PropertyPermission("*", "read,write"));
  295.    }
  296.  
  297.    public void checkPropertyAccess(String var1) {
  298.       this.checkPermission(new PropertyPermission(var1, "read"));
  299.    }
  300.  
  301.    public boolean checkTopLevelWindow(Object var1) {
  302.       if (var1 == null) {
  303.          throw new NullPointerException("window can't be null");
  304.       } else {
  305.          try {
  306.             this.checkPermission(SecurityConstants.TOPLEVEL_WINDOW_PERMISSION);
  307.             return true;
  308.          } catch (SecurityException var3) {
  309.             return false;
  310.          }
  311.       }
  312.    }
  313.  
  314.    public void checkPrintJobAccess() {
  315.       this.checkPermission(new RuntimePermission("queuePrintJob"));
  316.    }
  317.  
  318.    public void checkSystemClipboardAccess() {
  319.       this.checkPermission(SecurityConstants.ACCESS_CLIPBOARD_PERMISSION);
  320.    }
  321.  
  322.    public void checkAwtEventQueueAccess() {
  323.       this.checkPermission(SecurityConstants.CHECK_AWT_EVENTQUEUE_PERMISSION);
  324.    }
  325.  
  326.    private static String[] getPackages(String var0) {
  327.       String[] var1 = null;
  328.       if (var0 != null && !var0.equals("")) {
  329.          StringTokenizer var2 = new StringTokenizer(var0, ",");
  330.          int var3 = var2.countTokens();
  331.          if (var3 > 0) {
  332.             var1 = new String[var3];
  333.  
  334.             String var5;
  335.             for(int var4 = 0; var2.hasMoreElements(); var1[var4++] = var5) {
  336.                var5 = var2.nextToken().trim();
  337.             }
  338.          }
  339.       }
  340.  
  341.       if (var1 == null) {
  342.          var1 = new String[0];
  343.       }
  344.  
  345.       return var1;
  346.    }
  347.  
  348.    public void checkPackageAccess(String var1) {
  349.       if (var1 == null) {
  350.          throw new NullPointerException("package name can't be null");
  351.       } else {
  352.          String[] var2;
  353.          synchronized(packageAccessLock) {
  354.             if (!packageAccessValid) {
  355.                String var4 = (String)AccessController.doPrivileged(new 1(this));
  356.                packageAccess = getPackages(var4);
  357.                packageAccessValid = true;
  358.             }
  359.  
  360.             var2 = packageAccess;
  361.          }
  362.  
  363.          for(int var3 = 0; var3 < var2.length; ++var3) {
  364.             if (var1.startsWith(var2[var3]) || var2[var3].equals(var1 + ".")) {
  365.                this.checkPermission(new RuntimePermission("accessClassInPackage." + var1));
  366.                break;
  367.             }
  368.          }
  369.  
  370.       }
  371.    }
  372.  
  373.    public void checkPackageDefinition(String var1) {
  374.       if (var1 == null) {
  375.          throw new NullPointerException("package name can't be null");
  376.       } else {
  377.          String[] var2;
  378.          synchronized(packageDefinitionLock) {
  379.             if (!packageDefinitionValid) {
  380.                String var4 = (String)AccessController.doPrivileged(new 2(this));
  381.                packageDefinition = getPackages(var4);
  382.                packageDefinitionValid = true;
  383.             }
  384.  
  385.             var2 = packageDefinition;
  386.          }
  387.  
  388.          for(int var3 = 0; var3 < var2.length; ++var3) {
  389.             if (var1.startsWith(var2[var3]) || var2[var3].equals(var1 + ".")) {
  390.                this.checkPermission(new RuntimePermission("defineClassInPackage." + var1));
  391.                break;
  392.             }
  393.          }
  394.  
  395.       }
  396.    }
  397.  
  398.    public void checkSetFactory() {
  399.       this.checkPermission(new RuntimePermission("setFactory"));
  400.    }
  401.  
  402.    public void checkMemberAccess(Class<?> var1, int var2) {
  403.       if (var1 == null) {
  404.          throw new NullPointerException("class can't be null");
  405.       } else {
  406.          if (var2 != 0) {
  407.             Class[] var3 = this.getClassContext();
  408.             if (var3.length < 4 || var3[3].getClassLoader() != var1.getClassLoader()) {
  409.                this.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
  410.             }
  411.          }
  412.  
  413.       }
  414.    }
  415.  
  416.    public void checkSecurityAccess(String var1) {
  417.       this.checkPermission(new SecurityPermission(var1));
  418.    }
  419.  
  420.    private native Class currentLoadedClass0();
  421.  
  422.    public ThreadGroup getThreadGroup() {
  423.       return Thread.currentThread().getThreadGroup();
  424.    }
  425. }
  426.